home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 1810 / 1810.xpi / chrome / showcase.jar / content / cache.js next >
Encoding:
Text File  |  2010-01-17  |  22.6 KB  |  577 lines
  1. var showcaseCanvasCounter = 0;
  2.  
  3. // Tab cache
  4. function ShowcaseTabCache(b)
  5. {
  6.     this.browser = b;
  7.       this.thumb = null;
  8.     b.showcaseCache = this;
  9.  
  10.     b.addEventListener("pageshow", this, true);
  11.     b.addEventListener("resize", this, false);
  12.       if (ShowcaseCache.updateThumbnailWhenScroll) {
  13.         b.addEventListener("scroll", this, true);
  14.       }
  15. };
  16.  
  17. ShowcaseTabCache.prototype = {
  18.  
  19. QueryInterface: function(aIID) {
  20.     if (aIID.equals(Components.interfaces.nsITimerCallback) ||
  21.           aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
  22.         aIID.equals(Components.interfaces.nsISupports))
  23.         return this;
  24.  
  25.     throw Components.results.NS_NOINTERFACE;
  26. },
  27.  
  28. makeThumbnail: function () {
  29.     if (this.browser.currentURI != null &&
  30.         this.browser.currentURI.spec == "about:blank") {
  31.         this.thumb = null;
  32.         return;
  33.     }
  34.       if (!ShowcaseCache.activateCache) {
  35.         this.thumb = null;
  36.         return;
  37.        }
  38.  
  39.   var cacheWidth, cacheHeight;
  40.   
  41.   var targetWidth, targetHeight;
  42.  
  43.   if (ShowcaseCache.detectImage && (this.browser.contentDocument instanceof ImageDocument)) {
  44.     var img = this.browser.contentDocument.imageRequest.decoderObserver;
  45.     targetWidth = img.width;
  46.     targetHeight = img.height;
  47.   } else {
  48.     targetWidth = this.browser.contentWindow.innerWidth;
  49.     targetHeight = this.browser.contentWindow.innerHeight;
  50.   }
  51.  
  52.   if (targetWidth > targetHeight) {
  53.     if (targetWidth > ShowcaseCache.cacheSize) {
  54.       cacheWidth = ShowcaseCache.cacheSize;
  55.       cacheHeight = Math.ceil(ShowcaseCache.cacheSize * targetHeight / targetWidth);
  56.     } else {
  57.       cacheWidth = targetWidth;
  58.       cacheHeight = targetHeight;
  59.     }
  60.   } else {
  61.     if (targetHeight > ShowcaseCache.cacheSize) {
  62.       cacheHeight = ShowcaseCache.cacheSize;
  63.       cacheWidth = Math.ceil(ShowcaseCache.cacheSize * targetWidth / targetHeight);
  64.     } else {
  65.       cacheWidth = targetWidth;
  66.       cacheHeight = targetHeight;
  67.     }
  68.   }
  69.   
  70.   if (this.thumb == null) {
  71.     this.createThumbnail();
  72.   }
  73.  
  74.   this.thumb.width = cacheWidth;
  75.   this.thumb.height = cacheHeight;
  76.  
  77.   if (ShowcaseCache.currentShowcases.length < 1) {
  78.     window.setTimeout(drawThumbnail, 0, this);
  79.   }
  80. },
  81.  
  82. createThumbnail: function() {
  83.   this.thumb = document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
  84.   this.thumb.id = "cachecanvas" + showcaseCanvasCounter++;
  85. },
  86.  
  87. handleEvent: function (e) {
  88.       if (ShowcaseCache.currentShowcases.length > 0)
  89.         return;
  90.  
  91.       if (e.type == "scroll") {
  92.         if (!this._scrollTimer) {
  93.           this._scrollTimer = Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer);
  94.         }
  95.         this._scrollTimer.cancel();
  96.         this._scrollTimer.initWithCallback(this, 300, Components.interfaces.nsITimer.TYPE_ONE_SHOT);
  97.         this.waitingRepaint = true;
  98.       } else {
  99.         this.makeThumbnail();
  100.       }
  101. },
  102.  
  103. notify: function(timer) {
  104.   this.makeThumbnail();
  105.   this.waitingRepaint = false;
  106. },
  107.  
  108. unload: function() {
  109.       if (this.browser) {
  110.         this.browser.removeEventListener("pageshow", this, true);
  111.         this.browser.removeEventListener("resize", this, false);
  112.         if (ShowcaseCache.updateThumbnailWhenScroll) {
  113.           this.browser.removeEventListener("scroll", this, true);
  114.         }
  115.  
  116.         this.browser.showcaseCache = null;
  117.       }
  118.       this.browser = null;
  119.       if (this._scrollTimer) {
  120.         this._scrollTimer.cancel();
  121.         this._scrollTimer = undefined;
  122.       }
  123.       this.thumb = null;
  124. }
  125.  
  126. };
  127.  
  128. function drawThumbnail(target) {
  129.   if (target.drawingThumbnail) return;
  130.  
  131.   var currentWebBrowserPrint = target.browser.contentWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
  132.                    .getInterface(Components.interfaces.nsIWebBrowserPrint);
  133.  
  134.   if (currentWebBrowserPrint.doingPrint || currentWebBrowserPrint.doingPrintPreview) return;
  135.  
  136.   target.drawingThumbnail = true;
  137.   try {
  138.     var ctx = target.thumb.getContext("2d");
  139.     ctx.clearRect(0, 0, target.thumb.width, target.thumb.height);
  140.  
  141.     if (ShowcaseCache.detectImage && (target.browser.contentDocument instanceof ImageDocument)) {
  142.       var img = target.browser.contentDocument.imageRequest.decoderObserver;
  143.       ctx.drawImage(img, 0, 0, target.thumb.width, target.thumb.height);
  144.     } else {
  145.       ctx.save();
  146.       ctx.scale(target.thumb.width/target.browser.contentWindow.innerWidth, target.thumb.height/target.browser.contentWindow.innerHeight);
  147.  
  148.       ctx.drawWindow(target.browser.contentWindow, 
  149.         target.browser.contentWindow.scrollX, 
  150.         target.browser.contentWindow.scrollY, 
  151.         target.browser.contentWindow.innerWidth, 
  152.         target.browser.contentWindow.innerHeight, 
  153.         "rgb(255,255,255)");
  154.       ctx.restore();
  155.     }
  156.   } catch (e) {
  157.     //Paint thumbnail failed, probably because the thumbnail disappeared. Fail silently.
  158.   }
  159.   target.drawingThumbnail = false;
  160. }
  161.  
  162.  
  163. var ShowcaseCache = {
  164.   prefs: null,
  165.   activateCache: false,
  166.   cacheSize: 0,
  167.   isCaching: false,
  168.   detectImage: false,
  169.   enhancedTabBar: false,
  170.   allTabsButtonMode: -1,
  171.   updateThumbnailWhenScroll: false,
  172.   currentShowcases: null,
  173.   
  174.  
  175.     QueryInterface: function (aIID)
  176.     {
  177.     if (aIID.equals(Components.interfaces.nsIPrefBranchInternal) ||
  178.         aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
  179.         aIID.equals(Components.interfaces.nsISupports))
  180.         return this;
  181.  
  182.     throw Components.results.NS_NOINTERFACE;
  183.     },
  184.  
  185.     observe: function (aSubject, aTopic, aData)
  186.     {
  187.     if (aTopic != "nsPref:changed")
  188.         return;
  189.  
  190.     switch (aData) {
  191.     case "extensions.showcase.cacheSize":
  192.         ShowcaseCache.cacheSize = ShowcaseCache.prefs.getIntPref("cacheSize");
  193.         break;
  194.     case "extensions.showcase.activateCache":
  195.         ShowcaseCache.activateCache = ShowcaseCache.prefs.getBoolPref("activateCache");
  196.             if (ShowcaseCache.activateCache && !ShowcaseCache.isCaching) {
  197.               ShowcaseCache.enableCaching();
  198.             } else if (!ShowcaseCache.activateCache && ShowcaseCache.isCaching) {
  199.               ShowcaseCache.disableCaching();
  200.             }
  201.             break;
  202.     case "extensions.showcase.detectImage":
  203.         ShowcaseCache.detectImage = ShowcaseCache.prefs.getBoolPref("detectImage");
  204.             // Update image thumbnails if necessary
  205.             if (ShowcaseCache.isCaching) {
  206.               var totalTabs = getBrowser().tabContainer.childNodes.length;
  207.               for (var d=0; d<totalTabs; d++) {
  208.                 var browser = getBrowser().getBrowserForTab(getBrowser().tabContainer.childNodes.item(d));
  209.                 if (browser.showcaseCache && (browser.contentDocument instanceof ImageDocument)) {
  210.                   browser.showcaseCache.makeThumbnail();
  211.                 }
  212.               }
  213.             }
  214.             break;
  215.       case "extensions.showcase.updateThumbnailWhenScroll":
  216.         ShowcaseCache.updateThumbnailWhenScroll = ShowcaseCache.prefs.getBoolPref("updateThumbnailWhenScroll");
  217.             // Update image thumbnails if necessary
  218.             if (ShowcaseCache.isCaching) {
  219.               var totalTabs = getBrowser().tabContainer.childNodes.length;
  220.               for (var d=0; d<totalTabs; d++) {
  221.                 var browser = getBrowser().getBrowserForTab(getBrowser().tabContainer.childNodes.item(d));
  222.                 if (browser.showcaseCache) {
  223.                   if (ShowcaseCache.updateThumbnailWhenScroll) {
  224.                browser.addEventListener("scroll", browser.showcaseCache, true);
  225.                   } else {
  226.               browser.removeEventListener("scroll", browser.showcaseCache, true);
  227.                   }
  228.                 }
  229.               }
  230.             }
  231.             break;
  232.     case "extensions.showcase.enhancedTabBar":
  233.             var newEnhancedTabBar = ShowcaseCache.prefs.getBoolPref("enhancedTabBar n");
  234.             if (newEnhancedTabBar != ShowcaseCache.enhancedTabBar ) {
  235.               if (newEnhancedTabBar ) {
  236.                 ShowcaseCache.registerEnhancedTabBar();
  237.               } else {
  238.                 ShowcaseCache.unregisterEnhancedTabBar();
  239.               }
  240.               ShowcaseCache.enhancedTabBar  = newEnhancedTabBar ;
  241.             }
  242.  
  243.             break;
  244.     case "extensions.showcase.allTabsButtonMode":
  245.             ShowcaseCache.allTabsButtonMode = ShowcaseCache.prefs.getIntPref("allTabsButtonMode");
  246.             break;
  247.     }
  248.     },
  249.  
  250.  
  251.     catchNewTab: function(event) {
  252.       if (event.currentTarget != getBrowser().mPanelContainer)
  253.         return;
  254.       var targetPanel;
  255.       if (event.target.childNodes[1]) {
  256.         targetPanel = event.target.childNodes[1];
  257.       } else {
  258.         targetPanel = event.target;
  259.       }
  260.  
  261.       if (!targetPanel.showcaseCache) {
  262.         (new ShowcaseTabCache(targetPanel)).makeThumbnail();
  263.       }
  264.     },
  265.  
  266.      firefox2CatchNewTab: function(event) {
  267.       var targetPanel = event.target.linkedBrowser;
  268.       if (!targetPanel.showcaseCache) {
  269.         (new ShowcaseTabCache(targetPanel)).makeThumbnail();
  270.       }
  271.      },
  272.  
  273.     catchDestroyTab: function(event) {
  274.         if (event.relatedNode != getBrowser().mPanelContainer)
  275.           return;
  276.       var targetPanel;
  277.       if (event.target.childNodes[1]) {
  278.         targetPanel = event.target.childNodes[1];
  279.       } else {
  280.         targetPanel = event.target;
  281.       }
  282.       if (targetPanel.showcaseCache) {
  283.         targetPanel.showcaseCache.unload();
  284.         targetPanel.showcaseCache = undefined;
  285.       }
  286.     },
  287.  
  288.      firefox2CatchDestroyTab: function(event) {
  289.       var targetPanel = event.target.linkedBrowser;
  290.       if (targetPanel.showcaseCache) {
  291.         targetPanel.showcaseCache.unload();
  292.       }
  293.      },
  294.     
  295.      catchUpDoubleClick: function(event) {
  296.        var targetScrollBox = getBrowser().mTabContainer.mTabstrip;
  297.        var scrollSize = { };
  298.  
  299.        if (targetScrollBox.getAttribute("orient") == "horizontal") {
  300.          targetScrollBox.scrollBoxObject.getScrolledSize(scrollSize, {});
  301.        } else {
  302.          targetScrollBox.scrollBoxObject.getScrolledSize({}, scrollSize);
  303.        }
  304.        getBrowser().mTabContainer.mTabstrip.scrollByPixels(-scrollSize.value);
  305.      },
  306.  
  307.      catchDownDoubleClick: function(event) {
  308.        var targetScrollBox = getBrowser().mTabContainer.mTabstrip;
  309.        var scrollSize = { };
  310.  
  311.        if (targetScrollBox.getAttribute("orient") == "horizontal") {
  312.          targetScrollBox.scrollBoxObject.getScrolledSize(scrollSize, {});
  313.        } else {
  314.          targetScrollBox.scrollBoxObject.getScrolledSize({}, scrollSize);
  315.        }
  316.        getBrowser().mTabContainer.mTabstrip.scrollByPixels(scrollSize.value);
  317.      },
  318.  
  319.     registerEnhancedTabBar: function() {
  320.       try {
  321.         var gBrowser = getBrowser();
  322.         gBrowser.mTabContainer.mAllTabsPopup.addEventListener("popupshowing", ShowcaseCache.catchAllTabsPopupShowing, false);
  323.         if (typeof(gBrowser.mTabContainer.mAllTabsButton) != "undefined") {
  324.           gBrowser.mTabContainer.mAllTabsButton.setAttribute("context", "showcaseAllTabsPopup");
  325.         } else {
  326.           gBrowser.mTabContainer.mAllTabsBoxAnimate.nextSibling.setAttribute("context", "showcaseAllTabsPopup");
  327.         }
  328.         gBrowser.mTabContainer.mTabstrip._scrollButtonUp.setAttribute("context", "showcaseLeftTabsPopup");
  329.         gBrowser.mTabContainer.mTabstrip._scrollButtonDown.setAttribute("context", "showcaseRightTabsPopup");
  330.         gBrowser.mTabContainer.mTabstrip._scrollButtonUp.setAttribute("tooltip", "showcaseTooltipLeftArrow");
  331.         gBrowser.mTabContainer.mTabstrip._scrollButtonDown.setAttribute("tooltip", "showcaseTooltipRightArrow");
  332.         if (!gBrowser.mTabContainer.mTabstrip._scrollButtonUp.originalOnMouseDown) {
  333.           gBrowser.mTabContainer.mTabstrip._scrollButtonUp.originalOnMouseDown = gBrowser.mTabContainer.mTabstrip._scrollButtonUp.getAttribute("onmousedown");
  334.         }
  335.         gBrowser.mTabContainer.mTabstrip._scrollButtonUp.setAttribute("onmousedown", "if ((event.button != 2) && (!event.ctrlKey)) { " + gBrowser.mTabContainer.mTabstrip._scrollButtonUp.originalOnMouseDown + " }");
  336.         if (!gBrowser.mTabContainer.mTabstrip._scrollButtonDown.originalOnMouseDown) {
  337.           gBrowser.mTabContainer.mTabstrip._scrollButtonDown.originalOnMouseDown = gBrowser.mTabContainer.mTabstrip._scrollButtonDown.getAttribute("onmousedown");
  338.         }
  339.         gBrowser.mTabContainer.mTabstrip._scrollButtonDown.setAttribute("onmousedown", "if ((event.button != 2) & (!event.ctrlKey)) { " + gBrowser.mTabContainer.mTabstrip._scrollButtonDown.originalOnMouseDown + " }");
  340.         gBrowser.mTabContainer.mTabstrip._scrollButtonUp.addEventListener("dblclick", ShowcaseCache.catchUpDoubleClick, false);
  341.         gBrowser.mTabContainer.mTabstrip._scrollButtonDown.addEventListener("dblclick", ShowcaseCache.catchDownDoubleClick, false);
  342.       } catch (e) {
  343.       }
  344.     },
  345.  
  346.     unregisterEnhancedTabBar: function() {
  347.       try {
  348.         var gBrowser = getBrowser();
  349.         gBrowser.mTabContainer.mAllTabsPopup.removeEventListener("popupshowing", ShowcaseCache.catchAllTabsPopupShowing, false);
  350.         if (typeof(gBrowser.mTabContainer.mAllTabsButton) != "undefined") {
  351.           gBrowser.mTabContainer.mAllTabsButton.setAttribute("context", "");
  352.         } else {
  353.           gBrowser.mTabContainer.mAllTabsBoxAnimate.nextSibling.setAttribute("context", "");
  354.         }
  355.         gBrowser.mTabContainer.mTabstrip._scrollButtonUp.setAttribute("context", "");
  356.         gBrowser.mTabContainer.mTabstrip._scrollButtonDown.setAttribute("context", "");
  357.         gBrowser.mTabContainer.mTabstrip._scrollButtonUp.setAttribute("tooltip", "");
  358.         gBrowser.mTabContainer.mTabstrip._scrollButtonDown.setAttribute("tooltip", "");
  359.         if (gBrowser.mTabContainer.mTabstrip._scrollButtonUp.originalOnMouseDown) {
  360.           gBrowser.mTabContainer.mTabstrip._scrollButtonUp.setAttribute("onmousedown", gBrowser.mTabContainer.mTabstrip._scrollButtonUp.originalOnMouseDown);
  361.         }
  362.         if (gBrowser.mTabContainer.mTabstrip._scrollButtonDown.originalOnMouseDown) {
  363.           gBrowser.mTabContainer.mTabstrip._scrollButtonDown.originalOnMouseDown.setAttribute("onmousedown", gBrowser.mTabContainer.mTabstrip._scrollButtonDown.originalOnMouseDown);
  364.         }
  365.         gBrowser.mTabContainer.mTabstrip._scrollButtonUp.removeEventListener("dblclick", ShowcaseCache.catchUpDoubleClick, false);
  366.         gBrowser.mTabContainer.mTabstrip._scrollButtonDown.removeEventListener("dblclick", ShowcaseCache.catchDownDoubleClick, false);
  367.       } catch (e) {}
  368.     },
  369.     
  370.     calculateHiddenTabsLeft: function() {
  371.        var targetScrollBox = getBrowser().mTabContainer.mTabstrip;
  372.        var tabs = getBrowser().mTabContainer.childNodes;
  373.        var scrollSize = { };
  374.  
  375.        if (targetScrollBox.getAttribute("orient") == "horizontal") {
  376.          var xPos = { }
  377.          targetScrollBox.scrollBoxObject.getPosition(xPos, {});
  378.          if (xPos.value == 0)
  379.            return 0;
  380.          var currentX = 0;
  381.          var currentTab = 0;
  382.          while ((currentX < xPos.value) && (currentTab < tabs.length)) {
  383.            currentX += tabs[currentTab].boxObject.width;
  384.            currentTab++;
  385.          }
  386.          return currentTab;
  387.        } else {
  388.          var yPos = { }
  389.          targetScrollBox.scrollBoxObject.getPosition({}, yPos);
  390.          if (yPos.value == 0)
  391.            return 0;
  392.          var currentY = 0;
  393.          var currentTab = 0;
  394.          while ((currentY < yPos.value) && (currentTab < tabs.length)) {
  395.            currentY += tabs[currentTab].boxObject.height;
  396.            currentTab++;
  397.          }
  398.          return currentTab;
  399.        }
  400.     },
  401.  
  402.     calculateHiddenTabsRight: function() {
  403.        var targetScrollBox = getBrowser().mTabContainer.mTabstrip;
  404.        var tabs = getBrowser().mTabContainer.childNodes;
  405.        var scrollSize = { };
  406.  
  407.        if (targetScrollBox.getAttribute("orient") == "horizontal") {
  408.          var width = { };
  409.          targetScrollBox.scrollBoxObject.getScrolledSize(width, {});
  410.          var xPos = { }
  411.          targetScrollBox.scrollBoxObject.getPosition(xPos, {});
  412.          var currentX = width.value;
  413.          var currentTab = tabs.length - 1;
  414.          while ((currentX > (targetScrollBox._scrollbox.boxObject.width + xPos.value)) && (currentTab >= 0)) {
  415.            currentX -= tabs[currentTab].boxObject.width;
  416.            currentTab--;
  417.          }
  418.          return (tabs.length - 1 - currentTab);
  419.        } else {
  420.          var height  = { };
  421.          targetScrollBox.scrollBoxObject.getScrolledSize({}, height);
  422.          var yPos = { }
  423.          targetScrollBox.scrollBoxObject.getPosition({}, yPos);
  424.          var currentY = height.value;
  425.          var currentTab = tabs.length - 1;
  426.          while ((currentY > (targetScrollBox._scrollbox.boxObject.height + yPos.value)) && (currentTab >= 0)) {
  427.            currentY = tabs[currentTab].boxObject.height;
  428.            currentTab--;
  429.          }
  430.          return (tabs.length - 1 - currentTab);
  431.        }
  432.     },
  433.  
  434.     onLoad: function() {
  435.       ShowcaseCache.currentShowcases = new Array();
  436.       ShowcaseCache.prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService).getBranch("extensions.showcase.");
  437.       ShowcaseCache.activateCache = ShowcaseCache.prefs.getBoolPref("activateCache");
  438.       ShowcaseCache.cacheSize = ShowcaseCache.prefs.getIntPref("cacheSize");
  439.       ShowcaseCache.detectImage = ShowcaseCache.prefs.getBoolPref("detectImage");
  440.       ShowcaseCache.updateThumbnailWhenScroll = ShowcaseCache.prefs.getBoolPref("updateThumbnailWhenScroll");
  441.       ShowcaseCache.enhancedTabBar  = ShowcaseCache.prefs.getBoolPref("enhancedTabBar");
  442.       ShowcaseCache.allTabsButtonMode = ShowcaseCache.prefs.getIntPref("allTabsButtonMode");
  443.  
  444.       
  445.     Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch2).addObserver("extensions.showcase.", this, false);
  446.       
  447.  
  448.       if (ShowcaseCache.activateCache) {
  449.         ShowcaseCache.enableCaching();
  450.       }
  451.  
  452.       // Catch event if necessary
  453.       if (ShowcaseCache.enhancedTabBar  && getBrowser().mTabContainer.mAllTabsPopup) {
  454.         ShowcaseCache.registerEnhancedTabBar();
  455.       }
  456.  
  457.       setTimeout(function() {ShowcaseCache.showWelcomeScreenIfNeeded() }, 400);
  458.  
  459.  
  460.       },
  461.  
  462.       showWelcomeScreenIfNeeded: function() {
  463.         if (ShowcaseCache.prefs.getBoolPref("firstRunRedirection")) {
  464.           var currentVersion = ShowcaseCache.prefs.getCharPref("currentVersion");
  465.  
  466.           if (currentVersion != "0.9.5.5") {
  467.             ShowcaseCache.prefs.setCharPref("currentVersion", "0.9.5.5");
  468.             var targetURL;
  469.             if (currentVersion == "none") {
  470.               targetURL = "http://showcase.uworks.net/welcome.html";
  471.             } else {
  472.               targetURL = "http://showcase.uworks.net/updated.html";
  473.             }
  474.             var newTab = getBrowser().addTab(targetURL);
  475.             getBrowser().selectedTab = newTab;
  476.           }
  477.         }
  478.       },
  479.  
  480.       catchAllTabsPopupShowing: function(ev) {
  481.         switch (ShowcaseCache.allTabsButtonMode) {
  482.           case 0:
  483.             setTimeout(showShowcase, 0, false, false);
  484.             break;
  485.           case 1:
  486.             setTimeout(showShowcase, 0, true, false);
  487.             break;
  488.           case 2:
  489.             setTimeout(showShowcase, 0, false, true);
  490.             break;
  491.           case 3:
  492.             setTimeout(showShowcase, 0, true, true);
  493.             break;
  494.           case 4:
  495.             setTimeout(toggleSidebar, 0, 'viewShowcaseSidebar');
  496.             break;
  497.           case 5:
  498.             setTimeout(toggleSidebar, 0, 'viewShowcaseThisWindowSidebar');
  499.             break;
  500.         }
  501.         if (getBrowser().mTabContainer.mAllTabsPopup._onHidingAllTabsPopup)
  502.           getBrowser().mTabContainer.mAllTabsPopup._onHidingAllTabsPopup();
  503.  
  504.         ev.preventDefault();
  505.         return false;
  506.       },
  507.  
  508.       enableCaching: function() {
  509.       if (ShowcaseCache.isCaching) return;
  510.       if (typeof BrowserOpenAddonsMgr == "function") {
  511.         getBrowser().tabContainer.addEventListener("TabOpen", ShowcaseCache.firefox2CatchNewTab, false);
  512.         getBrowser().tabContainer.addEventListener("TabClose", ShowcaseCache.firefox2CatchDestroyTab, false);
  513.       } else {
  514.         getBrowser().mPanelContainer.addEventListener("DOMNodeInserted", ShowcaseCache.catchNewTab, false);
  515.         getBrowser().mPanelContainer.addEventListener("DOMNodeRemoved", ShowcaseCache.catchDestroyTab, false);
  516.       }
  517.  
  518.         var totalTabs = getBrowser().tabContainer.childNodes.length;
  519.         for (var d=0; d<totalTabs; d++) {
  520.         var currentShowcaseTabCache = new ShowcaseTabCache(getBrowser().getBrowserForTab(getBrowser().tabContainer.childNodes.item(d)));
  521.             currentShowcaseTabCache.makeThumbnail();
  522.       }
  523.         ShowcaseCache.isCaching = true;
  524.     },
  525.  
  526.     onUnload: function() {
  527.       if(typeof BrowserOpenAddonsMgr == "function") {
  528.         getBrowser().tabContainer.removeEventListener("TabOpen", ShowcaseCache.firefox2CatchNewTab, false);
  529.         getBrowser().tabContainer.removeEventListener("TabClose", ShowcaseCache.firefox2CatchDestroyTab, false);
  530.       } else {
  531.         getBrowser().mPanelContainer.removeEventListener("DOMNodeInserted", ShowcaseCache.catchNewTab, false);
  532.         getBrowser().mPanelContainer.removeEventListener("DOMNodeRemoved", ShowcaseCache.catchDestroyTab, false);
  533.       }
  534.  
  535.       
  536.     Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch2).removeObserver("extensions.showcase.", this);
  537.       
  538.  
  539.       if (ShowcaseCache.isCaching) {
  540.         ShowcaseCache.disableCaching();
  541.     }
  542.      },
  543.  
  544.      disableCaching: function() {
  545.         if (!ShowcaseCache.isCaching) return;
  546.         var totalTabs = getBrowser().tabContainer.childNodes.length;
  547.         for (var d=0; d<totalTabs; d++) {
  548.         var browser = getBrowser().getBrowserForTab(getBrowser().tabContainer.childNodes.item(d));
  549.            if (browser.showcaseCache) {
  550.              browser.showcaseCache.unload();
  551.            }
  552.        }
  553.        ShowcaseCache.isCaching = false;
  554.      },
  555.  
  556.      addShowcase: function(newShowcase) {
  557.        ShowcaseCache.currentShowcases.push(newShowcase);
  558.      },
  559.  
  560.      removeShowcase: function(targetShowcase) {
  561.        var targetIndex = ShowcaseCache.currentShowcases.indexOf(targetShowcase);
  562.  
  563.        if (targetIndex > -1) {
  564.          ShowcaseCache.currentShowcases.splice(targetIndex, 1);
  565.        }
  566.      }
  567. };
  568.  
  569. window.addEventListener("load", function(e) { ShowcaseCache.onLoad(); }, false);
  570. window.addEventListener("unload", function(e) { ShowcaseCache.onUnload(); }, false);
  571.  
  572. function debugLog(msg) {
  573.   var consoleService = Components.classes["@mozilla.org/consoleservice;1"]
  574.                                  .getService(Components.interfaces.nsIConsoleService);
  575.   consoleService.logStringMessage(msg);
  576. }
  577.